De Connection klasse

De connection klasse

Gebruiken

Om toegang tot de database te krijgen, moet je verbindingsparameters, zoals de machinenaam waarop de database staat en eventueel je logingegevens opgeven in wat we een connectiestring noemen.

Een voorbeeld van een connectiestring:

"Data Source=.\SQLEXPRESS;       
         Integrated Security=SSPI;          
         Initial Catalog=Webwinkel;         
         MultipleActiveResultSets=true" 

Er zitten drie belangrijke attributen in de connectiestring:

1. De Data Source is de naam van de SQL server instantie waarop de database staat.
2. Integrated Security wil zeggen dat je Windows Authentication gebruikt om je op de database aan te melden.
3. Initial Catalog is de naam van de database die wilt gebruiken.

Voor een lijst met voorbeelden kan je de website The Connection String Reference raadplegen.

Vooraleer je een database kan gebruiken moet je eerst een verbindingsobject maken. De verbinding zorgt ervoor dat de andere ADO.NET objecten weten met welke database ze te maken hebben. Het verbindingsobject handelt alle code af die te maken heeft met database protocollen. Dat maakt ons leven gemakkelijk omdat wij alleen nog maar een verbindingsobject moeten instantiëren, de verbinding openen en sluiten als we klaar zijn.

Hier is een voorbeeld van hoe je een instantie van de Connectionklasse maakt:

// een instantie maken van de SqlConnection klasse
SqlConnection connection = new SqlConnection();
// de eigenschap ConnectionString instellen
connection.ConnectionString = @"Data Source=.\SQLEXPRESS;Integrated Security = SSPI;Initial Catalog = Webwinkel;"; 

In het voorbeeld hierboven typen we de connectiestring rechtstreeks in de code. Het is een beter idee de connection string uit het configuratiebestand te halen. De connectie string plaats je eerste in het app.config bestand als je een Windows of een Console applicatie maakt of in het web.config bestand als je een webapplicatie maakt:

<connectionStrings>
  <add name="WebwinkelWindowsAuthentication"
        connectionString="Data Source=.\SQLEXPRESS;       
        Integrated Security=SSPI;          
        Initial Catalog=Webwinkel;" 
        providerName="System.Data.SqlClient" />
</connectionStrings>

Je kan de connectiestring halen uit de ConnectionStrings datadictionary van de ConfigurationManager klasse. Die zit in de namespace System.Configuration.

Dus boven de klasse geef je aan dat je de namespace wilt gebruiken:

using System.Configuration;

En in de methode van de klasse gebruik je de naam van de connectiestring als key om de connectiestring uit de datadictionary te halen:

connection.ConnectionString = ConfigurationManager.
ConnectionStrings["WebwinkelWindowsAuthentication"].ToString();

Connectie afsluiten

Ofschoon werken met verbindingsobjecten in ADO.NET een fluitje van een cent is, is het toch nodig om verbindingen goed te begrijpen zodat je de juiste beslissingen kan nemen bij het coderen. Je moet leren inzien dat een verbinding object een belangrijke ressource is. Voor een stand-alone applicatie, die draait op één enkele computer is dat misschien niet belangrijk. Maar denk aan een bedrijfsapplicatie waar honderden gebruikers dezelfde database gebruiken. Elke verbinding betekent overlast, en er zijn er maar een beperkt aantal van. Denk aan een extreem geval, een website die door duizenden bezoekers per dag gebruikt kan worden. Applicaties die verbindingen openen zonder ze te sluiten kunnen serieus negatieve gevolgen hebben voor de prestatie en schaalbaarheid.

Bij het gebruik van schaarse middelen in .NET zoals databaseverbindingen, windows of grafische objecten, is het verstandig om ervoor te zorgen dat elke resource na gebruik onmiddellijk gesloten wordt.

In .NET zit automatische garbagecollection. Toch is het aangewezen schaarse middelen zo vroeg mogelijk vrij te geven. Dit is des te belangrijk bij het schrijven van code die toegang geeft tot een database. Als je een verbinding langer laat open staan dan nodig kan dat invloed hebben op andere sessies. In extreme omstandigheden, kan het niet sluiten van een verbinding andere gebruikers de toegang tot bepaalde onderdelen van de applicatie verhinderen.

In de meeste vroegere applicaties bestond de gewoonte om een verbinding te openen wanneer de applicatie werd opgestart en afgesloten wanneer de applicatie werd beëindigd. Het openen van een databaseverbinding is een resource- en tijdsrovende bezigheid. De meeste databases kunnen slechts een beperkt aantal concurrerende verbindingen aan. De meeste hedendaagse data providers implementeren daarom connection pooling. Als je een verbinding met een database maakt wordt die in een pool gehouden. Wil je een verbinding voor je applicatie maken stelt de data provider de eerst beschikbare verbinding van de pool ter beschikking. Als de applicatie beëindigd wordt krijgt de pool de beschikking erover terug.

Dit betekent dat het openen en sluiten van een databaseverbinding geen resource- tijdsrovende bezigheid meer is. Als je een verbinding sluit houdt dat niet in dat je de verbinding met de database verbreekt, bij het sluiten wordt alleen de verbinding terug ter beschikking van de pool gesteld. Bij het openen krijgt een reeds open verbinding uit de pool een verbinding ter beschikking.

Daarom is het aanbevolen de beschikking over de verbindingen slechts zolang nodig is aan te houden.

Er bestaan twee manieren om ervoor te zorgen dat databaseverbindingen en dergelijke worden vrijgegeven:

1. try catch finally
2. using

Voorbeelden

Eenvoudige manier

We beginnen met de meest eenvoudige manier om het Connection object te leren gebruiken. Belangrijk is de connectie te leggen net vooraleer je ze nodig hebt. Als voorbeeld gebruiken we Insert van Bibliotex. We openen de connectie vlak voor het inserten en sluiten die onmiddellijk na het inserten weer af.

Met 'try catch finally'

// ik ga ervan uit dat het niet gelukt
int result = -1;
try
{
   connection.Open();
   this.feedback = "De database Bibliotex is geopend.";
   SqlCommand command = new SqlCommand();
   command.Connection = connection;
   command.CommandText = sql.ToString();
   result = command.ExecuteNonQuery();
}
   catch (SqlException e)
{
   this.feedback = "Kan de database Bibliotex niet openen.";
}
finally
{
   connection.Close();
}

Met 'using', en dat is de goede manier:

using (SqlConnection connection = new SqlConnection(connectionString))
{
    try
    {
        connection.Open();
        return "Connectie met SQL Server geslaagd.";
    }
    catch (SqlException e)
    {
        return e.Message;
    }
}

Connectiestrings beheren

De .NET manier: het App.Config of Web.config bestand

Vanaf .NET 2.0, kan je verbindingsreeksen opslaan en gebruiken databaseverbindingen op een type-agnostische manier. Je kan dan een toepassing schrijven en andere database providers toevoegen, zonder de hoofdtoepassing te wijzigen. Je definieert een databaseverbindingstekenreeks in de sectie <connectionStrings> van het configuratie bestand.

Deze code leest de verbindingsstring sectie (met de ConnectionStringSettings klasse), en vraagt vervolgens een provider factory van de basisklasse van DbProviderFactories. Deze maakt gebruik van de eigenschap ProviderName, die is ingesteld op "System.Data.SqlClient" in het configuratiebestand van de toepassing. Je zou je kunnen afvragen hoe dit wordt toegewezen aan de werkelijke factory-klasse die wordt gebruikt voor het genereren van een databaseverbinding voor SQL Server — in dit geval moet het gebruik maken van de klasse SqlClientFactory uit System.Data.SqlClient.

Je moet een verwijzing naar de System.Configuration-assembly toevoegen om op te lossen van de ConfigurationManager-klasse in de voorgaande code. Dit lijkt misschien als hoop onnodig werk voor een databaseverbinding.

Dat is inderdaad zo als je toepassing nooit met een andere database gaat laten werken.

Samenvatting

Door het gebruikt van het verbindingsobject weten andere ADO.NET objecten welke verbinding ze moeten gebruiken. De stappen die je moet zetten: zijn: de verbinding maken, openen, doorgeven, en sluiten. Vergewis je ervan dat de verbinding na gebruik weer gesloten is, om te vermijden dat resources verspild worden.